﻿using Awsc.DataAcquisitionSys.Core.Common.Attributes;
using Awsc.DataAcquisitionSys.Core.Common.Expressions;
using Awsc.DataAcquisitionSys.Core.Common.Extensions;
using System.ComponentModel;


namespace Awsc.DataAcquisitionSys.Core.Service.Alarm.Implement
{
    //public class ConditionAlarmRule: AlarmRule
    //{
    //    public string Expression { get; set; }
    //    public AlarmConditionGroup Condition { get; set; }


    //    public string BuildExpressionForCalculate()
    //    {
    //        Condition.IsRoot = true;
    //        return Condition.BuildExpressionForCalculate();
    //    }
    //    public string BuildExpression()
    //    {
    //        Condition.IsRoot = true;
    //        return Condition.BuildExpression();
    //    }
    //    public override string ToString()
    //    {
    //        return $"{Name}: {BuildExpression()}";
    //    }


    //    public override List<string> GetAllFieldNames()
    //    {
    //        var fieldNames = new HashSet<string>();
    //        if (Condition != null)
    //        {
    //            CollectFieldNames(Condition, fieldNames);
    //        }
    //        return fieldNames.ToList();
    //    }

    //    protected override bool Evaluate(Dictionary<string, object> parameters)
    //    {
    //        return Condition?.Evaluate(parameters) ?? false;
    //    }
    //    private void CollectFieldNames(AlarmConditionGroup condition, HashSet<string> fieldNames)
    //    {
    //        if (condition == null) return;
    //        foreach (var subCondition in condition.Conditions)
    //        {
    //            if (subCondition is AlarmConditionGroup group)
    //            {
    //                CollectFieldNames(group, fieldNames);
    //            }
    //            else if (subCondition is ConstCondition constCondition)
    //            {
    //                if (!string.IsNullOrEmpty(constCondition.LeftName))
    //                {
    //                    fieldNames.Add(constCondition.LeftName);
    //                }
    //            }
    //        }
    //    }
    //}

    //public class AlarmConditionGroup : IAlarmCondition
    //{
    //    public enum ConditionJoinType
    //    {
    //        [Description("且")]
    //        [DescriptionEx("&&")]
    //        And,
    //        [Description("或")]
    //        [DescriptionEx("||")]
    //        Or
    //    }

    //    public bool IsRoot { get; set; } // 是否为根条件组
    //    //public string LeftName { get; set; }

    //    public List<IAlarmCondition> Conditions { get; set; } = new List<IAlarmCondition>();
    //    public ConditionJoinType Connector { get; set; } = ConditionJoinType.And;


    //    public bool Evaluate(Dictionary<string, object> data)
    //    {
    //        if (!Conditions.Any())
    //        {
    //            return false;
    //        }

    //        if (Connector == ConditionJoinType.And)
    //        {
    //            foreach (var condition in Conditions)
    //            {
    //                if (!condition.Evaluate(data))
    //                {
    //                    return false;
    //                }
    //            }
    //            return true;
    //        }
    //        else if (Connector == ConditionJoinType.Or)
    //        {
    //            foreach (var condition in Conditions)
    //            {
    //                if (condition.Evaluate(data))
    //                {
    //                    return true;
    //                }
    //            }
    //            return false;
    //        }
    //        return false;
    //    }

    //    public string BuildExpression()
    //    {
    //        var expressions = Conditions.Select(c => c.BuildExpression()).ToList();
    //        if (IsRoot)
    //        {
    //            // 如果是根条件组，直接返回表达式，不加括号
    //            return string.Join($" {Connector.GetDescription()} ", expressions);
    //        }
    //        return "(" + string.Join($" {Connector.GetDescription()} ", expressions) + ")";
    //    }

    //    public string BuildExpressionForCalculate()
    //    {
    //        var expressions = Conditions.Select(c => c.BuildExpressionForCalculate()).ToList();
    //        if (IsRoot)
    //        {
    //            // 如果是根条件组，直接返回表达式，不加括号
    //            return string.Join($" {Connector.GetDescriptionEx()} ", expressions);
    //        }
    //        return "(" + string.Join($" {Connector.GetDescriptionEx()} ", expressions) + ")";
    //    }
    //}

    //public class ConstCondition : IAlarmCondition
    //{
    //    public string LeftName { get; set; }
    //    public object RightValue { get; set; }
    //    public OperatorType Operator { get; set; }
    //    public string Unit { get; set; }
    //    public bool Evaluate(object leftValue)
    //    {
    //        return ValueComparer.Compare(leftValue, RightValue, Operator);
    //    }
    //    public bool Evaluate(Dictionary<string, object> data)
    //    {
    //        if (data.ContainsKey(LeftName))
    //        {
    //            return Evaluate(data[LeftName]);
    //        }
    //        return false;
    //    }

    //    public string BuildExpression()
    //    {
    //        return $"{LeftName} {Operator.GetDescription()} {RightValue} {Unit}";
    //    }

    //    public string BuildExpressionForCalculate()
    //    {
    //        return $"{LeftName} {Operator.GetDescriptionEx()} {RightValue}";
    //    }
    //}

    //public interface IAlarmCondition
    //{
    //    //public string LeftName { get; set; }
    //    bool Evaluate(Dictionary<string, object> data);
    //    string BuildExpression();
    //    string BuildExpressionForCalculate();
    //}

    public class ConditionAlarmRule : AlarmRule
    {
        private ExpressionEvaluator _expressionEvaluator;



        public override string ToString()
        {
            return $"{Name}: {Condition}";
        }


        public override List<string> GetAllFieldNames()
        {
            return _expressionEvaluator.Fields;
        }

        protected override bool Evaluate(Dictionary<string, object> parameters)
        {
            foreach (var item in parameters)
            {
                _expressionEvaluator.SetVariable(item.Key, item.Value);
            }
            return _expressionEvaluator.Evaluate();
        }
    }

}
